import re
import json
import logging
from typing import List, Dict, Any, Optional
from app.models.schemas import TestCase, TestCaseRequest
from app.services.parsers import DocumentParser

# 获取日志记录器
logger = logging.getLogger(__name__)


class RequirementParserService:
    """需求文档解析服务，用于从需求文档中提取信息并生成测试用例"""

    def __init__(self):
        # 使用新的文档解析器
        self.document_parser = DocumentParser()

        # 保持向后兼容的属性
        self.supported_extensions = self.document_parser.get_supported_extensions()

    def parse_file_content(self, content: bytes, file_ext: str) -> str:
        """解析文件内容，提取需求描述 - 使用新的解析器架构"""
        try:
            logger.info(f"开始解析文件，类型: {file_ext}, 大小: {len(content)} 字节")

            # 使用新的文档解析器
            parsed_content = self.document_parser.parse_file_content(
                content, file_ext)

            logger.info(f"文档解析完成，内容长度: {len(parsed_content)} 字符")

            return parsed_content

        except Exception as e:
            logger.error(f"解析文件失败: {str(e)}")
            return "功能测试需求"

    # 以下方法已被新的解析器架构替代，保留用于向后兼容
    def get_file_info(self, content: bytes, file_ext: str) -> Dict[str, Any]:
        """获取文件信息"""
        return self.document_parser.get_file_info(content, file_ext)

    def validate_file(self, content: bytes, file_ext: str, filename: str = "") -> Dict[str, Any]:
        """验证文件"""
        return self.document_parser.validate_file(content, file_ext, filename)

    def extract_requirements(self, text: str) -> str:
        """从文本中提取需求描述 - 使用新的解析器"""
        # 委托给文档解析器处理
        parser = self.document_parser.parsers.get('.txt')
        if parser:
            return parser.extract_meaningful_content(text)
        return text[:500] if len(text) > 500 else text

    def extract_sections(self, content: str) -> Dict[str, List[str]]:
        """从文本中提取各个部分的内容 - 使用新的解析器"""
        parser = self.document_parser.parsers.get('.txt')
        if parser:
            return parser.extract_sections(content)
        return {"功能需求": [content]}

    def extract_flows(self, content: str) -> List[str]:
        """提取业务流程 - 使用新的解析器"""
        parser = self.document_parser.parsers.get('.txt')
        if parser:
            return parser.extract_flows(content)
        return []

    def extract_constraints(self, content: str) -> List[str]:
        """提取约束条件 - 使用新的解析器"""
        parser = self.document_parser.parsers.get('.txt')
        if parser:
            return parser.extract_constraints(content)
        return []

    def parse_requirement_document(self, content: str) -> Dict[str, Any]:
        """解析需求文档内容，提取关键信息"""
        logger.info("开始解析需求文档")

        # 初始化结果字典
        result = {
            "project_name": None,
            "module_name": None,
            "requirement": "",
            "sections": {},
            "flows": [],
            "constraints": [],
            "interfaces": [],
            "data_requirements": []
        }

        # 提取项目和模块名称 - 增强匹配模式
        project_patterns = [
            r'项目[名称|名]\s*[:：]\s*(.+?)[\n\r]',
            r'项目[名称|名]\s*[:：]\s*(.+?)$',
            r'项目[名称|名]\s*[:：]\s*(.+)',
            r'项目[:：]\s*(.+?)[\n\r]',
            r'项目[:：]\s*(.+?)$',
            r'项目[:：]\s*(.+)',
        ]

        for pattern in project_patterns:
            project_match = re.search(pattern, content, re.MULTILINE)
            if project_match:
                result["project_name"] = project_match.group(1).strip()
                break

        module_patterns = [
            r'模块[名称|名]\s*[:：]\s*(.+?)[\n\r]',
            r'模块[名称|名]\s*[:：]\s*(.+?)$',
            r'模块[名称|名]\s*[:：]\s*(.+)',
            r'模块[:：]\s*(.+?)[\n\r]',
            r'模块[:：]\s*(.+?)$',
            r'模块[:：]\s*(.+)',
        ]

        for pattern in module_patterns:
            module_match = re.search(pattern, content, re.MULTILINE)
            if module_match:
                result["module_name"] = module_match.group(1).strip()
                break

        # 提取各个部分的内容
        result["sections"] = self.extract_sections(content)

        # 提取业务流程
        result["flows"] = self.extract_flows(content)

        # 提取约束条件
        result["constraints"] = self.extract_constraints(content)

        # 组合需求描述
        requirement_parts = []

        # 添加功能需求
        if result["sections"]["功能需求"]:
            requirement_parts.extend(result["sections"]["功能需求"])

        # 添加业务规则
        if result["sections"]["业务规则"]:
            requirement_parts.append("\n业务规则：")
            requirement_parts.extend(result["sections"]["业务规则"])

        # 添加约束条件
        if result["constraints"]:
            requirement_parts.append("\n约束条件：")
            requirement_parts.extend(result["constraints"])

        # 添加性能需求
        if result["sections"]["性能需求"]:
            requirement_parts.append("\n性能需求：")
            requirement_parts.extend(result["sections"]["性能需求"])

        # 如果没有提取到任何内容，使用原始内容
        if not requirement_parts:
            requirement_parts = [content]

        result["requirement"] = "\n".join(requirement_parts)

        logger.info(
            f"需求文档解析完成，提取到 {len(result['sections'].get('功能需求', []))} 个功能需求")
        return result

    def generate_test_cases_from_document(self, content: str) -> TestCaseRequest:
        """从需求文档内容生成测试用例"""
        # 解析文档
        parsed_data = self.parse_requirement_document(content)

        # 创建测试用例请求对象
        request = TestCaseRequest(
            requirement=parsed_data["requirement"],
            project_name=parsed_data["project_name"],
            module_name=parsed_data["module_name"],
            additional_info=json.dumps({
                "sections": parsed_data["sections"],
                "flows": parsed_data["flows"],
                "constraints": parsed_data["constraints"]
            }, ensure_ascii=False)
        )

        return request
